home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2posx10.zoo / m2posix.10 / src / sig.dpp < prev    next >
Encoding:
Modula Definition  |  1993-11-04  |  14.2 KB  |  301 lines
  1. DEFINITION MODULE sig;
  2. __DEF_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* Signalbehandlung.                                                         *)
  14. (*                                                                           *)
  15. (* Ein Fehler ist immer dann aufgetreten, wenn bei Funktionen mit Typ INTEGER*)
  16. (* ein negativer Wert zurueckgegeben wird.                                   *)
  17. (* Die genaue Fehlerursache kann bei Bedarf ueber 'ERRNO.errno' und die      *)
  18. (* entsprechenden Konstanten ermittelt werden. Die Funktionen veraendern     *)
  19. (* 'errno' nur dann, wenn ein Fehler aufgetreten ist, bei erfolgreicher Aus- *)
  20. (* fuehrung wird 'errno' nicht veraendert.                                   *)
  21. (*                                                                           *)
  22. (* GEMDOS:                                                                   *)
  23. (* Die Eigenschaften der Funktionen unter dem ``blanken'' GEMDOS sind z.T.   *)
  24. (* stark eingeschraenkt; unter dem Stichwort GEMDOS ist deswegen immer       *)
  25. (* angegeben, in wieweit die Funktion emuliert werden kann. Ist MiNT-Unter-  *)
  26. (* stuetzung angegeben, so ist unter der Betriebssystemerweiterung MiNT      *)
  27. (* eine bessere Unterstuetzung der Funktionen zu erwarten; wie weit diese    *)
  28. (* geht, ist unter dem Stichwort MiNT angegeben.                             *)
  29. (* --------------------------------------------------------------------------*)
  30. (* 30-Okt-93, Holger Kleinschmidt                                            *)
  31. (*****************************************************************************)
  32.  
  33. FROM PORTAB IMPORT
  34. (* TYPE *) UNSIGNEDLONG, UNSIGNEDWORD, WORDSET;
  35.  
  36. FROM types IMPORT
  37. (* TYPE *) pidT;
  38.  
  39. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  40.  
  41. CONST
  42.   SigDfl = LC(0);
  43.   SigIgn = LC(1);
  44.  
  45.  
  46. TYPE
  47.   Signal = (
  48.     SIGNULL,   (* kein ``richtiges'' Signal, nicht POSIX *)
  49.     SIGHUP,
  50.     SIGINT,
  51.     SIGQUIT,
  52.     SIGILL,
  53.     SIGTRAP,   (* nicht POSIX *)
  54.     SIGABRT,
  55.     SIGPRIV,   (* nicht POSIX *)
  56.     SIGFPE,
  57.     SIGKILL,
  58.     SIGBUS,    (* nicht POSIX *)
  59.     SIGSEGV,
  60.     SIGSYS,    (* nicht POSIX *)
  61.     SIGPIPE,
  62.     SIGALRM,
  63.     SIGTERM,
  64.     SIGURG,    (* nicht POSIX *)
  65.     SIGSTOP,   (* nur unterstuetzt, falls ``Job Control'' vorhanden *)
  66.     SIGTSTP,   (* nur unterstuetzt, falls ``Job Control'' vorhanden *)
  67.     SIGCONT,   (* nur unterstuetzt, falls ``Job Control'' vorhanden *)
  68.     SIGCHLD,   (* nur unterstuetzt, falls ``Job Control'' vorhanden *)
  69.     SIGTTIN,   (* nur unterstuetzt, falls ``Job Control'' vorhanden *)
  70.     SIGTTOU,   (* nur unterstuetzt, falls ``Job Control'' vorhanden *)
  71.     SIGIO,     (* nicht POSIX *)
  72.     SIGXCPU,   (* nicht POSIX *)
  73.     SIGXFSZ,   (* nicht POSIX *)
  74.     SIGVTALRM, (* nicht POSIX *)
  75.     SIGPROF,   (* nicht POSIX *)
  76.     SIGWINCH,  (* nicht POSIX *)
  77.     SIGUSR1,
  78.     SIGUSR2
  79.   );
  80.  
  81. (* Die folgende Konstante muss je nach Anzahl der Signale von Hand
  82.  * neu berechnet werden.
  83.  *)
  84. CONST
  85.   MAXSIGSET = 1; (* := ORD(MAX(Signal)) DIV (ORD(MAX(WORDSETRANGE))+1) *)
  86.  
  87. TYPE
  88.   SigsetRange = [0..MAXSIGSET];
  89.  
  90. TYPE
  91.   SigsetPtr = POINTER TO sigsetT;
  92.  
  93. TYPE
  94.   (* Implementierung des Typs nur zur Benutzung innerhalb dieses Moduls *)
  95.   sigsetT = ARRAY SigsetRange OF WORDSET;
  96.  
  97.  
  98. TYPE
  99.   SigHandler = PROCEDURE((* EIN/ -- ) sig : *)Signal );
  100.  
  101. TYPE
  102.   SignalHandler = RECORD
  103.     CASE TAG_COLON BOOLEAN OF
  104.       FALSE: proc : SigHandler;
  105.      |TRUE : long : UNSIGNEDLONG; (* fuer 'SigIgn', 'SigDfl' *)
  106.     END;
  107.   END;
  108.  
  109. TYPE
  110. #if reverse_set
  111.   SaFlags = (
  112.     Sa15, Sa14, Sa13, Sa12, Sa11, Sa10,
  113.     Sa9, Sa8, Sa7, Sa6, Sa5, Sa4, Sa3, Sa2, Sa1,
  114.     SaNoCldStop (* Stoppen eines Unterprozesses erzeugt kein Signal *)
  115.   );
  116. #else
  117.   SaFlags = (
  118.     SaNoCldStop, (* Stoppen eines Unterprozesses erzeugt kein Signal *)
  119.     Sa1, Sa2, Sa3, Sa4, Sa5, Sa6, Sa7, Sa8, Sa9,
  120.     Sa10, Sa11, Sa12, Sa13, Sa14, Sa15
  121.   );
  122. #endif
  123.  
  124. TYPE
  125.   SigactionPtr = POINTER TO SigactionRec;
  126.  
  127.   SigactionRec = RECORD
  128.     saHandler : SignalHandler; (* Funktion fuer Signalbehandlung *)
  129.     saMask    : sigsetT;       (* zusaetzlich blockierte Signale waehrend *)
  130.                                (* der Abarbeitung des Signals *)
  131.     saFlags   : SaFlags;       (* Flags, die Signalbehandlung beeinflussen *)
  132.   END;
  133.  
  134.  
  135. TYPE
  136.   BlockType = (
  137.     SigBlock,   (* angegebene Signale zusaetzlich blockieren *)
  138.     SigUnBlock, (* angegebene Signale nicht blockieren *)
  139.     SigSetMask  (* ausschliesslich die angegebenen Signale blockieren *)
  140.   );
  141.  
  142. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  143.  
  144.  PROCEDURE sigemptyset ((* -- /AUS *) VAR set : sigsetT );
  145.  
  146.  PROCEDURE sigfillset ((* -- /AUS *) VAR set : sigsetT );
  147.  
  148.  PROCEDURE sigaddset ((* EIN/AUS *) VAR set : sigsetT;
  149.                       (* EIN/ -- *)     sig : Signal  ): INTEGER;
  150.  
  151.  PROCEDURE sigdelset ((* EIN/AUS *) VAR set : sigsetT;
  152.                       (* EIN/ -- *)     sig : Signal  ): INTEGER;
  153.  
  154.  PROCEDURE sigismember ((* EIN/ -- *) set : sigsetT;
  155.                         (* EIN/ -- *) sig : Signal  ): INTEGER;
  156.  
  157. (*--------------------------------------------------------------------------
  158.  | Die Funktionen stellen Operationen fuer das Arbeiten mit dem Typ         |
  159.  | 'sigsetT' dar. Es sollten ausschliesslich diese Funktionen benutzt werden|
  160.  | Es werden nur die uebergebenen Variablen manipuliert, fuer das Aendern   |
  161.  | Signalmaske des Prozesses ist z.B. "sigprocmask()" zu verwenden!         |
  162.  |                                                                          |
  163.  | "sigemptyset": erstellt eine Signalmaske, in der kein Signal gesetzt ist.|
  164.  | "sigfillset" : erstellt eine Signalmaske, in der alle Signale gesetzt    |
  165.  |                sind.                                                     |
  166.  | "sigaddset"  : Fuegt das Signal <sig> zur Signalmaske hinzu.             |
  167.  | "sigdelset"  : Entfernt das Signal <sig> aus der Signalmaske.            |
  168.  | "sigismember": Testet, ob das Signal <sig> in der Signalmaske enthalten  |
  169.  |                ist; liefert als Funktionswert eins, falls das Signal ent-|
  170.  |                halten ist, Null sonst.                                   |
  171.  |                                                                          |
  172.  | GEMDOS: Keine Besonderheiten.                                            |
  173.  |   MiNT: -""-                                                             |
  174.   --------------------------------------------------------------------------*)
  175.  
  176.  
  177.  PROCEDURE sigaction ((* EIN/ -- *) sig  : Signal;
  178.                       (* EIN/ -- *) act  : SigactionPtr;
  179.                       (* EIN/ -- *) oact : SigactionPtr ): INTEGER;
  180.  
  181. (*--------------------------------------------------------------------------
  182.  | Mit dieser Funktion kann festgelegt werden, welche Funktionen beim Auf-  |
  183.  | treten eines bestimmten Signals ausgefuehrt werden soll, und welche      |
  184.  | Signale waehrend der Ausfuehrung des ``Signalhandlers'' zusaetzlich zum  |
  185.  | ausloesenden Signal blockiert werden sollen.                             |
  186.  | Falls <act> oder <oact> gleich NULL sind (nicht NIL!), werden sie igno-  |
  187.  | riert.                                                                   |
  188.  |                                                                          |
  189.  | GEMDOS: (noch) nicht implementiert                                       |
  190.  |   MiNT: -""-                                                             |
  191.   --------------------------------------------------------------------------*)
  192.  
  193.  
  194.  PROCEDURE sigprocmask ((* EIN/ -- *) how  : BlockType;
  195.                         (* EIN/ -- *) set  : SigsetPtr;
  196.                         (* EIN/ -- *) oset : SigsetPtr ): INTEGER;
  197.  
  198. (*--------------------------------------------------------------------------
  199.  | Mit dieser Funktion kann der aufrufende Prozess seine Signalmaske ver-   |
  200.  | aendern, d.h. festlegen, welche Signale blockiert werden sollen.         |
  201.  |                                                                          |
  202.  | <how> = SigBlock  : Die Signalmaske ist die Vereinigung der bisherigen   |
  203.  |                     Maske mit <set>.                                     |
  204.  | <how> = SigUnBlock: Die Signalmaske ist die Differenz der bisherigen     |
  205.  |                     Maske und <set>.                                     |
  206.  | <how> = SigSetMask: <set> wird zur aktuellen Signalmaske.                |
  207.  |                                                                          |
  208.  | In <oset>^ wird die bisherige Signalmaske zurueckgeliefert.              |
  209.  | Falls <set> oder <oset> gleich NULL sind (nicht NIL!), werden sie igno-  |
  210.  | riert.                                                                   |
  211.  |                                                                          |
  212.  | GEMDOS: Keine Besonderheiten.                                            |
  213.  |   MiNT: -""-                                                             |
  214.   --------------------------------------------------------------------------*)
  215.  
  216.  
  217.  PROCEDURE sigpending ((* -- /AUS *) VAR set : sigsetT ): INTEGER;
  218.  
  219. (*--------------------------------------------------------------------------
  220.  | Ermittelt, welche Signale fuer den Prozess generiert wurden, aber zur    |
  221.  | Zeit blockiert sind.                                                     |
  222.  |                                                                          |
  223.  | GEMDOS: Keine Besonderheiten.                                            |
  224.  |   MiNT: -""-                                                             |
  225.   --------------------------------------------------------------------------*)
  226.  
  227.  
  228.  PROCEDURE kill ((* EIN/ -- *) pid : pidT;
  229.                  (* EIN/ -- *) sig : Signal ): INTEGER;
  230.  
  231. (*--------------------------------------------------------------------------
  232.  | Sendet das Signal <sig> an den Prozess oder die Prozessgruppe <pid>.     |
  233.  |                                                                          |
  234.  | <pid> >  0: <sig> wird an den Prozess mit der Kennung <pid> gesendet.    |
  235.  | <pid> =  0: <sig> wird an alle Prozesse gesendet, die in der gleichen    |
  236.  |             Prozessgruppe wie der aufrufende Prozess sind.               |
  237.  | <pid> = -1: systemspezifische Aktion.                                    |
  238.  | <pid> < -1: <sig> wird an alle Prozesse gesendet, die in der Prozess-    |
  239.  |             gruppe |<pid>| sind.                                         |
  240.  |                                                                          |
  241.  | GEMDOS: Ein Signal kann nur an sich selbst gesendet werden.              |
  242.  |   MiNT: Keine Besonderheiten.                                            |
  243.   --------------------------------------------------------------------------*)
  244.  
  245.  
  246.  PROCEDURE pause ( ): INTEGER;
  247.  
  248.  PROCEDURE sigsuspend ((* EIN/ -- *) sigmask : sigsetT ): INTEGER;
  249.  
  250. (*--------------------------------------------------------------------------
  251.  | "pause()" suspendiert den aufrufenden Prozess bis ein Signal auftritt.   |
  252.  | Bei "sigsuspend()" kann festgelegt werden, welche Signale waehrend des   |
  253.  | Wartens blockiert sind.                                                  |
  254.  | Falls das Signal durch einen Handler abgefangen wird, der normal zurueck-|
  255.  | kehrt, wird -1 zurueckgeliefert und 'errno' auf 'EINTR' gesetzt, sonst   |
  256.  | wird der Prozess terminiert.                                             |
  257.  |                                                                          |
  258.  | GEMDOS: kehrt immer mit -1 zurueck (errno = 'EINTR').                    |
  259.  |   MiNT: Keine Besonderheiten.                                            |
  260.   --------------------------------------------------------------------------*)
  261.  
  262.  
  263.  
  264.  PROCEDURE sleep ((* EIN/ -- *) seconds : CARDINAL ): CARDINAL;
  265.  
  266. (*--------------------------------------------------------------------------
  267.  | Suspendiert den aufrufenden Prozess fuer <seconds> Sekunden, oder bis    |
  268.  | ein Signal auftritt. Als Funktionswert wird Null zurueckgegeben oder, bei|
  269.  | Auftreten eines Signals, die Differenz der bisher verstrichenen Zeit zu  |
  270.  | <seconds>.                                                               |
  271.  | "sleep()" und "alarm()" sollten moeglichst nicht beide in einem Programm |
  272.  | benutzt werden.                                                          |
  273.  | Aus Portabilitaetsgruenden sollte <seconds> nicht groesser als 65535 sein|
  274.  |                                                                          |
  275.  | GEMDOS: Es wird ein ``Busy waiting'' durchgefuehrt.                      |
  276.  |   MiNT: Vor Version 1.08 kann keine Unterbrechung durch ein Signal statt-|
  277.  |         finden.                                                          |
  278.  | Es wird immer Null zurueckgeliefert.                                     |
  279.   --------------------------------------------------------------------------*)
  280.  
  281.  
  282.  PROCEDURE alarm ((* EIN/ -- *) seconds : CARDINAL ): CARDINAL;
  283.  
  284. (*--------------------------------------------------------------------------
  285.  | Sendet das Signal 'SIGALRM' nach <seconds> Sekunden an den aufrufenden   |
  286.  | Prozess. Wenn kein entsprechender Handler installiert wurde, wird der    |
  287.  | Prozess nach der angegebenen Zeit terminiert. Ist <seconds> gleich Null, |
  288.  | wird ein zuvor in Auftrag gegebener Alarm zurueckgesetzt.                |
  289.  | Als Funktionswert werden die Anzahl Sekunden bis zu einem evtl. frueher  |
  290.  | eingeplanten Alarm zurueckgeliefert.                                     |
  291.  | "sleep()" und "alarm()" sollten moeglichst nicht beide in einem Programm |
  292.  | benutzt werden.                                                          |
  293.  | Aus Portabilitaetsgruenden sollte <seconds> nicht groesser als 65535 sein|
  294.  |                                                                          |
  295.  | GEMDOS: Es wird Null zurueckgegeben und nichts passiert.                 |
  296.  |   MiNT: Keine Besonderheiten.                                            |
  297.   --------------------------------------------------------------------------*)
  298.  
  299. END sig.
  300.  
  301.